home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / EvalMod.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  37KB  |  1,084 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_StringMem
  20. #include "StringMem.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Texts
  24. #include "Texts.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Sets
  28. #include "Sets.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_TreeMod1
  32. #include "TreeMod1.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeMod2
  36. #include "TreeMod2.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_EvalMod3
  40. #include "EvalMod3.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Tree
  44. #include "Tree.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_EvalMod
  48. #include "EvalMod.h"
  49. #endif
  50.  
  51. Tree_tTree EvalMod_Class;
  52. IO_tFile EvalMod_yyf;
  53. PROC EvalMod_Exit;
  54.  
  55. static SHORTCARD n;
  56. static Tree_tTree Node, Attr, ChildsClass;
  57. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  58. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  59. struct S_3 {
  60.     union {
  61.         char dummy;
  62.     } U_1;
  63. };
  64. struct S_4 {
  65.     union {
  66.         char dummy;
  67.     } U_1;
  68. };
  69. struct S_5 {
  70.     union {
  71.         char dummy;
  72.     } U_1;
  73. };
  74. static void WriteType ARGS((Tree_tTree t));
  75. struct S_6 {
  76.     union {
  77.         char dummy;
  78.     } U_1;
  79. };
  80. struct S_7 {
  81.     union {
  82.         struct {
  83.             struct S_8 {
  84.                 Tree_tTree TheClass;
  85.                 INTEGER k;
  86.             } yyR8;
  87.         } V_1;
  88.     } U_1;
  89. };
  90. static void yyExit ARGS(());
  91.  
  92.  
  93. static void yyAbort
  94. # ifdef __STDC__
  95. (CHAR yyFunction[], LONGCARD O_1)
  96. # else
  97. (yyFunction, O_1)
  98. CHAR yyFunction[];
  99. LONGCARD O_1;
  100. # endif
  101. {
  102.   OPEN_ARRAY_LOCALS
  103.  
  104.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  105.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  106.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module EvalMod, routine ", 31L);
  107.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  108.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  109.   IO_WriteNl((System_tFile)IO_StdError);
  110.   (*EvalMod_Exit)();
  111.   FREE_OPEN_ARRAYS
  112. }
  113.  
  114. static BOOLEAN yyIsEqual
  115. # ifdef __STDC__
  116. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  117. # else
  118. (yya, O_3, yyb, O_2)
  119. BYTE yya[];
  120. LONGCARD O_3;
  121. BYTE yyb[];
  122. LONGCARD O_2;
  123. # endif
  124. {
  125.   INTEGER yyi;
  126.   OPEN_ARRAY_LOCALS
  127.  
  128.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  129.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  130.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  131.   {
  132.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  133.  
  134.     if (B_1 <= B_2)
  135.       for (yyi = B_1;; yyi += 1) {
  136.         if (yya[yyi] != yyb[yyi]) {
  137.           FREE_OPEN_ARRAYS
  138.           return FALSE;
  139.         }
  140.         if (yyi >= B_2) break;
  141.       }
  142.   }
  143.   FREE_OPEN_ARRAYS
  144.   return TRUE;
  145. }
  146.  
  147. void EvalMod_EvalDefMod
  148. # ifdef __STDC__
  149. (Tree_tTree t)
  150. # else
  151. (t)
  152. Tree_tTree t;
  153. # endif
  154. {
  155.   struct S_3 yyTempo;
  156.  
  157.   if (t == Tree_NoTree) {
  158.     return;
  159.   }
  160.   if (t->U_1.V_1.Kind == Tree_Ag) {
  161.     {
  162.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  163.  
  164.       IO_WriteS(Tree_f, (STRING)"DEFINITION MODULE ", 18L);
  165.       Tree_WI(W_1->EvalName);
  166.       IO_WriteS(Tree_f, (STRING)";", 1L);
  167.       IO_WriteNl(Tree_f);
  168.       IO_WriteNl(Tree_f);
  169.       IO_WriteS(Tree_f, (STRING)"IMPORT ", 7L);
  170.       Tree_WI(Tree_iMain);
  171.       IO_WriteS(Tree_f, (STRING)";", 1L);
  172.       IO_WriteNl(Tree_f);
  173.       TreeMod2_WriteLine(W_1->EvalCodes->U_1.V_12.Codes.ImportLine);
  174.       Texts_WriteText(Tree_f, W_1->EvalCodes->U_1.V_12.Codes.Import);
  175.       Node = W_1->Modules;
  176.       while (Node->U_1.V_1.Kind == Tree_Module) {
  177.         TreeMod2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.ImportLine);
  178.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Import);
  179.         Node = Node->U_1.V_43.Module.Next;
  180.       }
  181.       TreeMod2_WriteLine(W_1->EvalCodes->U_1.V_12.Codes.ExportLine);
  182.       Texts_WriteText(Tree_f, W_1->EvalCodes->U_1.V_12.Codes.Export);
  183.       Node = W_1->Modules;
  184.       while (Node->U_1.V_1.Kind == Tree_Module) {
  185.         TreeMod2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.ExportLine);
  186.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Export);
  187.         Node = Node->U_1.V_43.Module.Next;
  188.       }
  189.       IO_WriteNl(Tree_f);
  190.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Eval (yyt: ", 21L);
  191.       Tree_WI(Tree_iMain);
  192.       IO_WriteS(Tree_f, (STRING)".", 1L);
  193.       Tree_WI(Tree_itTree);
  194.       IO_WriteS(Tree_f, (STRING)");", 2L);
  195.       IO_WriteNl(Tree_f);
  196.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Begin", 15L);
  197.       Tree_WI(W_1->EvalName);
  198.       IO_WriteS(Tree_f, (STRING)";", 1L);
  199.       IO_WriteNl(Tree_f);
  200.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Close", 15L);
  201.       Tree_WI(W_1->EvalName);
  202.       IO_WriteS(Tree_f, (STRING)";", 1L);
  203.       IO_WriteNl(Tree_f);
  204.       IO_WriteNl(Tree_f);
  205.       IO_WriteS(Tree_f, (STRING)"END ", 4L);
  206.       Tree_WI(W_1->EvalName);
  207.       IO_WriteS(Tree_f, (STRING)".", 1L);
  208.       IO_WriteNl(Tree_f);
  209.       return;
  210.     }
  211.   }
  212. }
  213.  
  214. void EvalMod_EvalImplHead
  215. # ifdef __STDC__
  216. (Tree_tTree t)
  217. # else
  218. (t)
  219. Tree_tTree t;
  220. # endif
  221. {
  222.   struct S_4 yyTempo;
  223.  
  224.   if (t == Tree_NoTree) {
  225.     return;
  226.   }
  227.   if (t->U_1.V_1.Kind == Tree_Ag) {
  228.     {
  229.       register Tree_yAg *W_2 = &t->U_1.V_26.Ag;
  230.  
  231.       IO_WriteS(Tree_f, (STRING)"# define DEP(a, b) a", 20L);
  232.       IO_WriteNl(Tree_f);
  233.       IO_WriteS(Tree_f, (STRING)"# define SELF yyt", 17L);
  234.       IO_WriteNl(Tree_f);
  235.       IO_WriteS(Tree_f, (STRING)"IMPLEMENTATION MODULE ", 22L);
  236.       Tree_WI(W_2->EvalName);
  237.       IO_WriteS(Tree_f, (STRING)";", 1L);
  238.       IO_WriteNl(Tree_f);
  239.       IO_WriteNl(Tree_f);
  240.       IO_WriteS(Tree_f, (STRING)"IMPORT SYSTEM, ", 15L);
  241.       Tree_WI(Tree_iMain);
  242.       IO_WriteS(Tree_f, (STRING)";", 1L);
  243.       IO_WriteNl(Tree_f);
  244.       if (Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options)) {
  245.         IO_WriteS(Tree_f, (STRING)"IMPORT Layout, Strings, Idents, Texts, Sets;", 44L);
  246.         IO_WriteNl(Tree_f);
  247.       }
  248.       if (Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options) || Sets_IsElement(ORD('L'), &Tree_Options) || Sets_IsElement(ORD('9'), &Tree_Options)) {
  249.         IO_WriteS(Tree_f, (STRING)"IMPORT IO;", 10L);
  250.         IO_WriteNl(Tree_f);
  251.       }
  252.       if (Sets_IsElement(ORD('9'), &Tree_Options)) {
  253.         IO_WriteS(Tree_f, (STRING)"IMPORT General;", 15L);
  254.         IO_WriteNl(Tree_f);
  255.       }
  256.       TreeMod2_WriteLine(W_2->EvalCodes->U_1.V_12.Codes.GlobalLine);
  257.       Texts_WriteText(Tree_f, W_2->EvalCodes->U_1.V_12.Codes.Global);
  258.       Node = W_2->Modules;
  259.       while (Node->U_1.V_1.Kind == Tree_Module) {
  260.         TreeMod2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.GlobalLine);
  261.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Global);
  262.         Node = Node->U_1.V_43.Module.Next;
  263.       }
  264.       IO_WriteNl(Tree_f);
  265.       IO_WriteS(Tree_f, (STRING)"VAR yyb    : BOOLEAN;", 18L);
  266.       IO_WriteNl(Tree_f);
  267.       if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  268.         IO_WriteS(Tree_f, (STRING)"# include \"yy", 13L);
  269.         Tree_WI(Tree_iModule);
  270.         IO_WriteS(Tree_f, (STRING)".w\"", 3L);
  271.         IO_WriteNl(Tree_f);
  272.         IO_WriteS(Tree_f, (STRING)"# define yyWrite", 16L);
  273.         Tree_WI(Tree_iMain);
  274.         IO_WriteS(Tree_f, (STRING)"(a) ", 4L);
  275.         Tree_WI(Tree_iMain);
  276.         IO_WriteS(Tree_f, (STRING)".Write", 6L);
  277.         Tree_WI(Tree_iMain);
  278.         IO_WriteS(Tree_f, (STRING)" (yyf, a)", 9L);
  279.         IO_WriteNl(Tree_f);
  280.         IO_WriteNl(Tree_f);
  281.         IO_WriteS(Tree_f, (STRING)"VAR yyf    : IO.tFile;", 19L);
  282.         IO_WriteNl(Tree_f);
  283.         IO_WriteNl(Tree_f);
  284.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteHex (VAR yyx: ARRAY OF SYSTEM.BYTE);", 53L);
  285.         IO_WriteNl(Tree_f);
  286.         IO_WriteS(Tree_f, (STRING)" VAR yyi    : INTEGER;", 19L);
  287.         IO_WriteNl(Tree_f);
  288.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  289.         IO_WriteNl(Tree_f);
  290.         IO_WriteS(Tree_f, (STRING)"  IF yyTrace THEN", 17L);
  291.         IO_WriteNl(Tree_f);
  292.         IO_WriteS(Tree_f, (STRING)"   FOR yyi := 0 TO INTEGER (HIGH (yyx)) DO", 42L);
  293.         IO_WriteNl(Tree_f);
  294.         IO_WriteS(Tree_f, (STRING)"    IO.WriteN (yyf, ORD (CHAR (yyx [yyi])), 2, 16);", 51L);
  295.         IO_WriteNl(Tree_f);
  296.         IO_WriteS(Tree_f, (STRING)"    IO.WriteC (yyf, ' ');", 25L);
  297.         IO_WriteNl(Tree_f);
  298.         IO_WriteS(Tree_f, (STRING)"   END;", 7L);
  299.         IO_WriteNl(Tree_f);
  300.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  301.         IO_WriteNl(Tree_f);
  302.         IO_WriteS(Tree_f, (STRING)" END yyWriteHex;", 16L);
  303.         IO_WriteNl(Tree_f);
  304.         IO_WriteNl(Tree_f);
  305.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteNl;", 20L);
  306.         IO_WriteNl(Tree_f);
  307.         IO_WriteS(Tree_f, (STRING)" BEGIN IF yyTrace THEN", 22L);
  308.         IO_WriteNl(Tree_f);
  309.         IO_WriteS(Tree_f, (STRING)"  IO.WriteNl (IO.StdOutput); IO.WriteFlush (IO.StdOutput);", 58L);
  310.         IO_WriteNl(Tree_f);
  311.         IO_WriteS(Tree_f, (STRING)" END; END yyWriteNl;", 20L);
  312.         IO_WriteNl(Tree_f);
  313.       }
  314.       if (Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options)) {
  315.         IO_WriteNl(Tree_f);
  316.         IO_WriteS(Tree_f, (STRING)"CONST yyTrace = TRUE;", 21L);
  317.         IO_WriteNl(Tree_f);
  318.         IO_WriteNl(Tree_f);
  319.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteS (yys: ARRAY OF CHAR);", 40L);
  320.         IO_WriteNl(Tree_f);
  321.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  322.         IO_WriteNl(Tree_f);
  323.         IO_WriteS(Tree_f, (STRING)"  IO.WriteS (IO.StdOutput, yys); Layout.WriteSpaces (IO.StdOutput, 15 - INTEGER (HIGH (yys)));", 94L);
  324.         IO_WriteNl(Tree_f);
  325.         IO_WriteS(Tree_f, (STRING)" END yyWriteS;", 14L);
  326.         IO_WriteNl(Tree_f);
  327.         IO_WriteNl(Tree_f);
  328.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteType (yyt: ", 28L);
  329.         Tree_WI(Tree_iMain);
  330.         IO_WriteS(Tree_f, (STRING)".", 1L);
  331.         Tree_WI(Tree_itTree);
  332.         IO_WriteS(Tree_f, (STRING)");", 2L);
  333.         IO_WriteNl(Tree_f);
  334.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  335.         IO_WriteNl(Tree_f);
  336.         IO_WriteS(Tree_f, (STRING)"  CASE yyt^.Kind OF", 19L);
  337.         IO_WriteNl(Tree_f);
  338.         Tree_ForallClasses(W_2->Classes, (Tree_ProcOfT)WriteType);
  339.         IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  340.         IO_WriteNl(Tree_f);
  341.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  342.         IO_WriteNl(Tree_f);
  343.         IO_WriteS(Tree_f, (STRING)" END yyWriteType;", 17L);
  344.         IO_WriteNl(Tree_f);
  345.       }
  346.       if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  347.         IO_WriteNl(Tree_f);
  348.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteEval (yyt: ", 28L);
  349.         Tree_WI(Tree_iMain);
  350.         IO_WriteS(Tree_f, (STRING)".", 1L);
  351.         Tree_WI(Tree_itTree);
  352.         IO_WriteS(Tree_f, (STRING)"; yys: ARRAY OF CHAR);", 22L);
  353.         IO_WriteNl(Tree_f);
  354.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  355.         IO_WriteNl(Tree_f);
  356.         IO_WriteS(Tree_f, (STRING)"  IF yyTrace THEN", 17L);
  357.         IO_WriteNl(Tree_f);
  358.         IO_WriteS(Tree_f, (STRING)"   yyWriteType (yyt);", 21L);
  359.         IO_WriteNl(Tree_f);
  360.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, ' e ');", 35L);
  361.         IO_WriteNl(Tree_f);
  362.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, yys);", 33L);
  363.         IO_WriteNl(Tree_f);
  364.         IO_WriteS(Tree_f, (STRING)"   Layout.WriteSpaces (IO.StdOutput, 23 - INTEGER (HIGH (yys)));", 64L);
  365.         IO_WriteNl(Tree_f);
  366.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, ' = ');", 35L);
  367.         IO_WriteNl(Tree_f);
  368.         IO_WriteS(Tree_f, (STRING)"   IO.WriteFlush (IO.StdOutput);", 32L);
  369.         IO_WriteNl(Tree_f);
  370.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  371.         IO_WriteNl(Tree_f);
  372.         IO_WriteS(Tree_f, (STRING)" END yyWriteEval;", 17L);
  373.         IO_WriteNl(Tree_f);
  374.       } else if (Sets_IsElement(ORD('Y'), &Tree_Options)) {
  375.         IO_WriteNl(Tree_f);
  376.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteEval (yyt: ", 28L);
  377.         Tree_WI(Tree_iMain);
  378.         IO_WriteS(Tree_f, (STRING)".", 1L);
  379.         Tree_WI(Tree_itTree);
  380.         IO_WriteS(Tree_f, (STRING)"; yys: ARRAY OF CHAR);", 22L);
  381.         IO_WriteNl(Tree_f);
  382.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  383.         IO_WriteNl(Tree_f);
  384.         IO_WriteS(Tree_f, (STRING)"  IF yyTrace THEN", 17L);
  385.         IO_WriteNl(Tree_f);
  386.         IO_WriteS(Tree_f, (STRING)"   yyWriteType (yyt);", 21L);
  387.         IO_WriteNl(Tree_f);
  388.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, ' e ');", 35L);
  389.         IO_WriteNl(Tree_f);
  390.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, yys);", 33L);
  391.         IO_WriteNl(Tree_f);
  392.         IO_WriteS(Tree_f, (STRING)"   IO.WriteNl (IO.StdOutput);", 29L);
  393.         IO_WriteNl(Tree_f);
  394.         IO_WriteS(Tree_f, (STRING)"   IO.WriteFlush (IO.StdOutput);", 32L);
  395.         IO_WriteNl(Tree_f);
  396.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  397.         IO_WriteNl(Tree_f);
  398.         IO_WriteS(Tree_f, (STRING)" END yyWriteEval;", 17L);
  399.         IO_WriteNl(Tree_f);
  400.       }
  401.       if (Sets_IsElement(ORD('Z'), &Tree_Options)) {
  402.         IO_WriteNl(Tree_f);
  403.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyWriteVisit (yyt: ", 29L);
  404.         Tree_WI(Tree_iMain);
  405.         IO_WriteS(Tree_f, (STRING)".", 1L);
  406.         Tree_WI(Tree_itTree);
  407.         IO_WriteS(Tree_f, (STRING)"; yys: ARRAY OF CHAR);", 22L);
  408.         IO_WriteNl(Tree_f);
  409.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  410.         IO_WriteNl(Tree_f);
  411.         IO_WriteS(Tree_f, (STRING)"  IF yyTrace THEN", 17L);
  412.         IO_WriteNl(Tree_f);
  413.         IO_WriteS(Tree_f, (STRING)"   yyWriteType (yyt);", 21L);
  414.         IO_WriteNl(Tree_f);
  415.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, ' v ');", 35L);
  416.         IO_WriteNl(Tree_f);
  417.         IO_WriteS(Tree_f, (STRING)"   IO.WriteS (IO.StdOutput, yys);", 33L);
  418.         IO_WriteNl(Tree_f);
  419.         IO_WriteS(Tree_f, (STRING)"   IO.WriteNl (IO.StdOutput);", 29L);
  420.         IO_WriteNl(Tree_f);
  421.         IO_WriteS(Tree_f, (STRING)"   IO.WriteFlush (IO.StdOutput);", 32L);
  422.         IO_WriteNl(Tree_f);
  423.         IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  424.         IO_WriteNl(Tree_f);
  425.         IO_WriteS(Tree_f, (STRING)" END yyWriteVisit;", 18L);
  426.         IO_WriteNl(Tree_f);
  427.         IO_WriteNl(Tree_f);
  428.         IO_WriteS(Tree_f, (STRING)"PROCEDURE yyVisitParent (yyt: ", 30L);
  429.         Tree_WI(Tree_iMain);
  430.         IO_WriteS(Tree_f, (STRING)".", 1L);
  431.         Tree_WI(Tree_itTree);
  432.         IO_WriteS(Tree_f, (STRING)");", 2L);
  433.         IO_WriteNl(Tree_f);
  434.         IO_WriteS(Tree_f, (STRING)" BEGIN yyWriteVisit (yyt, 'parent'); END yyVisitParent;", 55L);
  435.         IO_WriteNl(Tree_f);
  436.       }
  437.       return;
  438.     }
  439.   }
  440. }
  441.  
  442. void EvalMod_EvalImplMod
  443. # ifdef __STDC__
  444. (Tree_tTree t)
  445. # else
  446. (t)
  447. Tree_tTree t;
  448. # endif
  449. {
  450.   struct S_5 yyTempo;
  451.  
  452.   if (t == Tree_NoTree) {
  453.     return;
  454.   }
  455.   if (t->U_1.V_1.Kind == Tree_Ag) {
  456.     {
  457.       register Tree_yAg *W_3 = &t->U_1.V_26.Ag;
  458.  
  459.       EvalMod_EvalImplHead(t);
  460.       if (!Sets_IsElement(ORD('9'), &Tree_Options)) {
  461.         IO_WriteNl(Tree_f);
  462.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Eval (yyt: ", 21L);
  463.         Tree_WI(Tree_iMain);
  464.         IO_WriteS(Tree_f, (STRING)".", 1L);
  465.         Tree_WI(Tree_itTree);
  466.         IO_WriteS(Tree_f, (STRING)");", 2L);
  467.         IO_WriteNl(Tree_f);
  468.         IO_WriteS(Tree_f, (STRING)" BEGIN ", 7L);
  469.         if (Tree_MaxVisit > 0) {
  470.           IO_WriteS(Tree_f, (STRING)"yyVisit1 (yyt); ", 16L);
  471.         }
  472.         IO_WriteS(Tree_f, (STRING)"END Eval;", 9L);
  473.         IO_WriteNl(Tree_f);
  474.       } else {
  475.         IO_WriteNl(Tree_f);
  476.         IO_WriteS(Tree_f, (STRING)"VAR xxStack: CARDINAL;", 22L);
  477.         IO_WriteNl(Tree_f);
  478.         IO_WriteNl(Tree_f);
  479.         IO_WriteS(Tree_f, (STRING)"PROCEDURE Eval (yyt: ", 21L);
  480.         Tree_WI(Tree_iMain);
  481.         IO_WriteS(Tree_f, (STRING)".", 1L);
  482.         Tree_WI(Tree_itTree);
  483.         IO_WriteS(Tree_f, (STRING)");", 2L);
  484.         IO_WriteNl(Tree_f);
  485.         IO_WriteS(Tree_f, (STRING)" VAR xxHigh: BOOLEAN;", 21L);
  486.         IO_WriteNl(Tree_f);
  487.         IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  488.         IO_WriteNl(Tree_f);
  489.         IO_WriteS(Tree_f, (STRING)"  xxStack := MAX (INTEGER);", 27L);
  490.         IO_WriteNl(Tree_f);
  491.         if (Tree_MaxVisit > 0) {
  492.           IO_WriteS(Tree_f, (STRING)"  yyVisit1 (yyt);", 17L);
  493.           IO_WriteNl(Tree_f);
  494.         }
  495.         IO_WriteS(Tree_f, (STRING)"  IO.WriteS (IO.StdOutput, 'Stacksize ');", 41L);
  496.         IO_WriteNl(Tree_f);
  497.         IO_WriteS(Tree_f, (STRING)"  IO.WriteI (IO.StdOutput, CARDINAL (SYSTEM.ADR (xxHigh)) - xxStack, 0);", 72L);
  498.         IO_WriteNl(Tree_f);
  499.         IO_WriteS(Tree_f, (STRING)"  IO.WriteNl (IO.StdOutput);", 28L);
  500.         IO_WriteNl(Tree_f);
  501.         IO_WriteS(Tree_f, (STRING)" END Eval;", 10L);
  502.         IO_WriteNl(Tree_f);
  503.       }
  504.       IO_WriteNl(Tree_f);
  505.       {
  506.         SHORTCARD B_3 = 1, B_4 = Tree_MaxVisit;
  507.  
  508.         if (B_3 <= B_4)
  509.           for (n = B_3;; n += 1) {
  510.             IO_WriteS(Tree_f, (STRING)"PROCEDURE yyVisit", 17L);
  511.             Tree_WN((LONGINT)n);
  512.             IO_WriteS(Tree_f, (STRING)" (yyt: ", 7L);
  513.             Tree_WI(Tree_iMain);
  514.             IO_WriteS(Tree_f, (STRING)".", 1L);
  515.             Tree_WI(Tree_itTree);
  516.             IO_WriteS(Tree_f, (STRING)");", 2L);
  517.             IO_WriteNl(Tree_f);
  518.             TreeMod2_WriteLine(W_3->EvalCodes->U_1.V_12.Codes.LocalLine);
  519.             Texts_WriteText(Tree_f, W_3->EvalCodes->U_1.V_12.Codes.Local);
  520.             Node = W_3->Modules;
  521.             while (Node->U_1.V_1.Kind == Tree_Module) {
  522.               TreeMod2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.LocalLine);
  523.               Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Local);
  524.               Node = Node->U_1.V_43.Module.Next;
  525.             }
  526.             if (Sets_IsElement(ORD('9'), &Tree_Options)) {
  527.               IO_WriteS(Tree_f, (STRING)" VAR xxLow: BOOLEAN;", 20L);
  528.               IO_WriteNl(Tree_f);
  529.               IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  530.               IO_WriteNl(Tree_f);
  531.               IO_WriteS(Tree_f, (STRING)"  xxStack := General.Min (xxStack, CARDINAL (SYSTEM.ADR (xxLow)));", 66L);
  532.               IO_WriteNl(Tree_f);
  533.             } else {
  534.               IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  535.               IO_WriteNl(Tree_f);
  536.             }
  537.             IO_WriteS(Tree_f, (STRING)"  CASE yyt^.Kind OF", 19L);
  538.             IO_WriteNl(Tree_f);
  539.             if (IN(Tree_cOAG, Tree_GrammarClass)) {
  540.               Tree_ForallClasses(W_3->Classes, (Tree_ProcOfT)EvalMod_GenEvaluator);
  541.             }
  542.             IO_WriteS(Tree_f, (STRING)"  ELSE", 6L);
  543.             IO_WriteNl(Tree_f);
  544.             if (Sets_IsElement(ORD('Z'), &Tree_Options)) {
  545.               IO_WriteS(Tree_f, (STRING)"   yyVisitParent (yyt);", 23L);
  546.               IO_WriteNl(Tree_f);
  547.             }
  548.             IO_WriteS(Tree_f, (STRING)"  END;", 6L);
  549.             IO_WriteNl(Tree_f);
  550.             IO_WriteS(Tree_f, (STRING)" END yyVisit", 12L);
  551.             Tree_WN((LONGINT)n);
  552.             IO_WriteS(Tree_f, (STRING)";", 1L);
  553.             IO_WriteNl(Tree_f);
  554.             IO_WriteNl(Tree_f);
  555.             if (n >= B_4) break;
  556.           }
  557.       }
  558.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Begin", 15L);
  559.       Tree_WI(W_3->EvalName);
  560.       IO_WriteS(Tree_f, (STRING)";", 1L);
  561.       IO_WriteNl(Tree_f);
  562.       IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  563.       IO_WriteNl(Tree_f);
  564.       TreeMod2_WriteLine(W_3->EvalCodes->U_1.V_12.Codes.BeginLine);
  565.       Texts_WriteText(Tree_f, W_3->EvalCodes->U_1.V_12.Codes.Begin);
  566.       Node = W_3->Modules;
  567.       while (Node->U_1.V_1.Kind == Tree_Module) {
  568.         TreeMod2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.BeginLine);
  569.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Begin);
  570.         Node = Node->U_1.V_43.Module.Next;
  571.       }
  572.       IO_WriteS(Tree_f, (STRING)" END Begin", 10L);
  573.       Tree_WI(W_3->EvalName);
  574.       IO_WriteS(Tree_f, (STRING)";", 1L);
  575.       IO_WriteNl(Tree_f);
  576.       IO_WriteNl(Tree_f);
  577.       IO_WriteS(Tree_f, (STRING)"PROCEDURE Close", 15L);
  578.       Tree_WI(W_3->EvalName);
  579.       IO_WriteS(Tree_f, (STRING)";", 1L);
  580.       IO_WriteNl(Tree_f);
  581.       IO_WriteS(Tree_f, (STRING)" BEGIN", 6L);
  582.       IO_WriteNl(Tree_f);
  583.       TreeMod2_WriteLine(W_3->EvalCodes->U_1.V_12.Codes.CloseLine);
  584.       Texts_WriteText(Tree_f, W_3->EvalCodes->U_1.V_12.Codes.Close);
  585.       Node = W_3->Modules;
  586.       while (Node->U_1.V_1.Kind == Tree_Module) {
  587.         TreeMod2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.CloseLine);
  588.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Close);
  589.         Node = Node->U_1.V_43.Module.Next;
  590.       }
  591.       IO_WriteS(Tree_f, (STRING)" END Close", 10L);
  592.       Tree_WI(W_3->EvalName);
  593.       IO_WriteS(Tree_f, (STRING)";", 1L);
  594.       IO_WriteNl(Tree_f);
  595.       IO_WriteNl(Tree_f);
  596.       IO_WriteS(Tree_f, (STRING)"BEGIN", 5L);
  597.       IO_WriteNl(Tree_f);
  598.       if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  599.         IO_WriteS(Tree_f, (STRING)" yyf := IO.StdOutput;", 21L);
  600.         IO_WriteNl(Tree_f);
  601.       }
  602.       IO_WriteS(Tree_f, (STRING)"END ", 4L);
  603.       Tree_WI(W_3->EvalName);
  604.       IO_WriteS(Tree_f, (STRING)".", 1L);
  605.       IO_WriteNl(Tree_f);
  606.       return;
  607.     }
  608.   }
  609. }
  610.  
  611. static void WriteType
  612. # ifdef __STDC__
  613. (Tree_tTree t)
  614. # else
  615. (t)
  616. Tree_tTree t;
  617. # endif
  618. {
  619.   struct S_6 yyTempo;
  620.  
  621.   if (t == Tree_NoTree) {
  622.     return;
  623.   }
  624.   if (t->U_1.V_1.Kind == Tree_Class) {
  625.     for (;;) {
  626.       {
  627.         register Tree_yClass *W_4 = &t->U_1.V_5.Class;
  628.  
  629.         if (!((Tree_NoCodeClass & W_4->Properties) == 0X0L)) {
  630.           goto EXIT_1;
  631.         }
  632.         if (!IN(Tree_Trace, W_4->Properties)) {
  633.           goto EXIT_1;
  634.         }
  635.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  636.         Tree_WI(Tree_TreeRoot->U_1.V_26.Ag.TreeName);
  637.         IO_WriteS(Tree_f, (STRING)".", 1L);
  638.         Tree_WI(W_4->Name);
  639.         IO_WriteS(Tree_f, (STRING)": yyWriteS ('", 13L);
  640.         Tree_WI(W_4->Name);
  641.         IO_WriteS(Tree_f, (STRING)"');", 3L);
  642.         IO_WriteNl(Tree_f);
  643.         return;
  644.       }
  645.     } EXIT_1:;
  646.   }
  647. }
  648.  
  649. void EvalMod_GenEvaluator
  650. # ifdef __STDC__
  651. (Tree_tTree t)
  652. # else
  653. (t)
  654. Tree_tTree t;
  655. # endif
  656. {
  657.   struct S_7 yyTempo;
  658.  
  659.   if (t == Tree_NoTree) {
  660.     return;
  661.   }
  662.   switch (t->U_1.V_1.Kind) {
  663.   case Tree_Class:;
  664.     for (;;) {
  665.       {
  666.         register Tree_yClass *W_5 = &t->U_1.V_5.Class;
  667.  
  668.         if (!((Tree_NoCodeClass & W_5->Properties) == 0X0L)) {
  669.           goto EXIT_2;
  670.         }
  671.         if (W_5->Generated == W_5->InstCount || W_5->Visits < n) {
  672.           return;
  673.         }
  674.         IO_WriteS(Tree_f, (STRING)"| ", 2L);
  675.         Tree_WI(Tree_TreeRoot->U_1.V_26.Ag.TreeName);
  676.         IO_WriteS(Tree_f, (STRING)".", 1L);
  677.         Tree_WI(W_5->Name);
  678.         IO_WriteS(Tree_f, (STRING)":", 1L);
  679.         IO_WriteNl(Tree_f);
  680.         EvalMod_Class = t;
  681.         for (;;) {
  682.           if (W_5->Generated == W_5->InstCount) {
  683.             goto EXIT_3;
  684.           }
  685.           INC(W_5->Generated);
  686.           {
  687.             register Tree_tInstance *W_6 = &W_5->Instance->A[W_5->Instance->A[W_5->Generated - 1].Order - 1];
  688.  
  689.             if (IN(Tree_Left, W_6->Properties) && W_6->Attribute->U_1.V_9.Child.Partition > n) {
  690.               DEC(W_5->Generated);
  691.               goto EXIT_3;
  692.             }
  693.             if (SET_IS_SUBSET1(SET_ELEM(Tree_Inherited) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_6->Properties) && !IN(Tree_Virtual, W_6->Properties)) {
  694.               if (Sets_IsElement(ORD('X'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  695.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, '", 19L);
  696.                 Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  697.                 IO_WriteS(Tree_f, (STRING)":", 1L);
  698.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  699.                 IO_WriteS(Tree_f, (STRING)"');", 3L);
  700.                 IO_WriteNl(Tree_f);
  701.                 if (W_6->Action != ADR(W_6->Action)) {
  702.                   EvalMod_GenEvaluator(W_6->Action);
  703.                 }
  704.                 IO_WriteNl(Tree_f);
  705.                 if (W_6->Attribute->U_1.V_1.Kind == Tree_Child || W_6->Attribute->U_1.V_10.Attribute.Type == Tree_itTree) {
  706.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  707.                   Tree_WI(Tree_itTree);
  708.                   IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  709.                   Tree_WI(W_5->Name);
  710.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  711.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  712.                   IO_WriteS(Tree_f, (STRING)"^.", 2L);
  713.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Type);
  714.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  715.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  716.                   IO_WriteS(Tree_f, (STRING)")", 1L);
  717.                   IO_WriteNl(Tree_f);
  718.                 } else {
  719.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  720.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Type);
  721.                   IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  722.                   Tree_WI(W_5->Name);
  723.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  724.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  725.                   IO_WriteS(Tree_f, (STRING)"^.", 2L);
  726.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Type);
  727.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  728.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  729.                   IO_WriteS(Tree_f, (STRING)") yyWriteNl;", 12L);
  730.                   IO_WriteNl(Tree_f);
  731.                 }
  732.               } else if (Sets_IsElement(ORD('Y'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  733.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, '", 19L);
  734.                 Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  735.                 IO_WriteS(Tree_f, (STRING)":", 1L);
  736.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  737.                 IO_WriteS(Tree_f, (STRING)"');", 3L);
  738.                 IO_WriteNl(Tree_f);
  739.                 if (W_6->Action != ADR(W_6->Action)) {
  740.                   EvalMod_GenEvaluator(W_6->Action);
  741.                 }
  742.               } else {
  743.                 if (W_6->Action != ADR(W_6->Action)) {
  744.                   EvalMod_GenEvaluator(W_6->Action);
  745.                 }
  746.               }
  747.             }
  748.             if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Left) | SET_ELEM(Tree_First), W_6->Properties) && ((SET_ELEM(Tree_Dummy) | SET_ELEM(Tree_Virtual)) & W_6->Properties) == 0X0L) {
  749.               if (Sets_IsElement(ORD('X'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  750.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, '", 19L);
  751.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  752.                 IO_WriteS(Tree_f, (STRING)"');", 3L);
  753.                 IO_WriteNl(Tree_f);
  754.                 if (W_6->Action != ADR(W_6->Action)) {
  755.                   EvalMod_GenEvaluator(W_6->Action);
  756.                 }
  757.                 IO_WriteNl(Tree_f);
  758.                 if (IN(Tree_Test, W_6->Properties)) {
  759.                   IO_WriteS(Tree_f, (STRING)"writeBOOLEAN (yyb) yyWriteNl;", 29L);
  760.                   IO_WriteNl(Tree_f);
  761.                 } else if (W_6->Attribute->U_1.V_1.Kind == Tree_Child || W_6->Attribute->U_1.V_10.Attribute.Type == Tree_itTree) {
  762.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  763.                   Tree_WI(Tree_itTree);
  764.                   IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  765.                   Tree_WI(W_5->Name);
  766.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  767.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  768.                   IO_WriteS(Tree_f, (STRING)")", 1L);
  769.                 } else {
  770.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  771.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Type);
  772.                   IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  773.                   Tree_WI(W_5->Name);
  774.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  775.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  776.                   IO_WriteS(Tree_f, (STRING)") yyWriteNl;", 12L);
  777.                   IO_WriteNl(Tree_f);
  778.                 }
  779.               } else if (Sets_IsElement(ORD('Y'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  780.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, '", 19L);
  781.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  782.                 IO_WriteS(Tree_f, (STRING)"');", 3L);
  783.                 IO_WriteNl(Tree_f);
  784.                 if (W_6->Action != ADR(W_6->Action)) {
  785.                   EvalMod_GenEvaluator(W_6->Action);
  786.                 }
  787.               } else {
  788.                 if (W_6->Action != ADR(W_6->Action)) {
  789.                   EvalMod_GenEvaluator(W_6->Action);
  790.                 }
  791.               }
  792.             }
  793.             if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_6->Properties) && W_6->Attribute->U_1.V_9.Child.Partition <= W_6->Selector->U_1.V_9.Child.Class->U_1.V_5.Class.Visits) {
  794.               if (Sets_IsElement(ORD('Z'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  795.                 IO_WriteS(Tree_f, (STRING)"yyWriteVisit (yyt, '", 20L);
  796.                 Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  797.                 IO_WriteS(Tree_f, (STRING)" ", 1L);
  798.                 Tree_WN((LONGINT)W_6->Attribute->U_1.V_9.Child.Partition);
  799.                 IO_WriteS(Tree_f, (STRING)"');", 3L);
  800.                 IO_WriteNl(Tree_f);
  801.               }
  802.               IO_WriteS(Tree_f, (STRING)"yyVisit", 7L);
  803.               Tree_WN((LONGINT)W_6->Attribute->U_1.V_9.Child.Partition);
  804.               IO_WriteS(Tree_f, (STRING)" (yyt^.", 7L);
  805.               Tree_WI(W_5->Name);
  806.               IO_WriteS(Tree_f, (STRING)".", 1L);
  807.               Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  808.               IO_WriteS(Tree_f, (STRING)");", 2L);
  809.               IO_WriteNl(Tree_f);
  810.             }
  811.           }
  812.         } EXIT_3:;
  813.         if (Sets_IsElement(ORD('Z'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  814.           IO_WriteS(Tree_f, (STRING)"yyVisitParent (yyt);", 20L);
  815.           IO_WriteNl(Tree_f);
  816.         }
  817.         return;
  818.       }
  819.     } EXIT_2:;
  820.     break;
  821.   case Tree_Assign:;
  822.     {
  823.       register Tree_yAssign *W_7 = &t->U_1.V_36.Assign;
  824.  
  825.       TreeMod2_WriteLine(W_7->Pos);
  826.       EvalMod_GenEvaluator(W_7->Results);
  827.       IO_WriteS(Tree_f, (STRING)":=", 2L);
  828.       EvalMod_GenEvaluator(W_7->Arguments);
  829.       IO_WriteS(Tree_f, (STRING)";", 1L);
  830.       IO_WriteNl(Tree_f);
  831.       return;
  832.     }
  833.     break;
  834.   case Tree_Copy:;
  835.     {
  836.       register Tree_yCopy *W_8 = &t->U_1.V_37.Copy;
  837.  
  838.       TreeMod2_WriteLine(W_8->Pos);
  839.       EvalMod_GenEvaluator(W_8->Results);
  840.       IO_WriteS(Tree_f, (STRING)":=", 2L);
  841.       EvalMod_GenEvaluator(W_8->Arguments);
  842.       IO_WriteS(Tree_f, (STRING)";", 1L);
  843.       IO_WriteNl(Tree_f);
  844.       return;
  845.     }
  846.     break;
  847.   case Tree_TargetCode:;
  848.     {
  849.       register Tree_yTargetCode *W_9 = &t->U_1.V_38.TargetCode;
  850.  
  851.       TreeMod2_WriteLine(W_9->Pos);
  852.       EvalMod_GenEvaluator(W_9->Code);
  853.       IO_WriteNl(Tree_f);
  854.       return;
  855.     }
  856.     break;
  857.   case Tree_Check:;
  858.     {
  859.       register Tree_yCheck *W_10 = &t->U_1.V_40.Check;
  860.  
  861.       TreeMod2_WriteLine(W_10->Pos);
  862.       if (W_10->Condition != Tree_NoTree) {
  863.         if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  864.           IO_WriteS(Tree_f, (STRING)"yyb := ", 7L);
  865.           EvalMod_GenEvaluator(W_10->Condition);
  866.           IO_WriteS(Tree_f, (STRING)"; IF NOT yyb THEN ", 18L);
  867.         } else {
  868.           IO_WriteS(Tree_f, (STRING)"IF NOT (", 8L);
  869.           EvalMod_GenEvaluator(W_10->Condition);
  870.           IO_WriteS(Tree_f, (STRING)") THEN ", 7L);
  871.         }
  872.         EvalMod_GenEvaluator(W_10->Statement);
  873.         IO_WriteNl(Tree_f);
  874.         if (W_10->Actions->U_1.V_1.Kind == Tree_Check) {
  875.           IO_WriteS(Tree_f, (STRING)"ELSE", 4L);
  876.           IO_WriteNl(Tree_f);
  877.           EvalMod_GenEvaluator(W_10->Actions);
  878.         }
  879.         IO_WriteS(Tree_f, (STRING)" END;", 5L);
  880.         IO_WriteNl(Tree_f);
  881.       } else {
  882.         if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  883.           IO_WriteS(Tree_f, (STRING)"yyb := FALSE; ", 14L);
  884.         }
  885.         EvalMod_GenEvaluator(W_10->Statement);
  886.         IO_WriteS(Tree_f, (STRING)";", 1L);
  887.         IO_WriteNl(Tree_f);
  888.         EvalMod_GenEvaluator(W_10->Actions);
  889.       }
  890.       return;
  891.     }
  892.     break;
  893.   case Tree_Designator:;
  894.     {
  895.       register Tree_yDesignator *W_11 = &t->U_1.V_15.Designator;
  896.  
  897.       Attr = Tree_IdentifyAttribute(EvalMod_Class, W_11->Selector);
  898.       if (Attr != Tree_NoTree) {
  899.         ChildsClass = Attr->U_1.V_9.Child.Class;
  900.         Attr = Tree_IdentifyAttribute(ChildsClass, W_11->Attribute);
  901.         if (!IN(Tree_Virtual, Attr->U_1.V_10.Attribute.Properties)) {
  902.           IO_WriteS(Tree_f, (STRING)"yyt^.", 5L);
  903.           Tree_WI(EvalMod_Class->U_1.V_5.Class.Name);
  904.           IO_WriteS(Tree_f, (STRING)".", 1L);
  905.           Tree_WI(W_11->Selector);
  906.           IO_WriteS(Tree_f, (STRING)"^.", 2L);
  907.           Tree_WI(ChildsClass->U_1.V_5.Class.Name);
  908.           IO_WriteS(Tree_f, (STRING)".", 1L);
  909.           Tree_WI(W_11->Attribute);
  910.         }
  911.       } else {
  912.         Tree_WI(W_11->Selector);
  913.         IO_WriteS(Tree_f, (STRING)":", 1L);
  914.         Tree_WI(W_11->Attribute);
  915.       }
  916.       EvalMod_GenEvaluator(W_11->Next);
  917.       return;
  918.     }
  919.     break;
  920.   case Tree_Ident:;
  921.     {
  922.       register Tree_yIdent *W_12 = &t->U_1.V_16.Ident;
  923.  
  924.       Attr = Tree_IdentifyAttribute(EvalMod_Class, W_12->Attribute);
  925.       if (Attr != Tree_NoTree) {
  926.         if (!IN(Tree_Virtual, Attr->U_1.V_10.Attribute.Properties)) {
  927.           IO_WriteS(Tree_f, (STRING)"yyt^.", 5L);
  928.           Tree_WI(EvalMod_Class->U_1.V_5.Class.Name);
  929.           IO_WriteS(Tree_f, (STRING)".", 1L);
  930.           Tree_WI(W_12->Attribute);
  931.         }
  932.       } else {
  933.         Tree_WI(W_12->Attribute);
  934.       }
  935.       EvalMod_GenEvaluator(W_12->Next);
  936.       return;
  937.     }
  938.     break;
  939.   case Tree_Remote:;
  940.     {
  941.       register struct S_8 *W_13 = &yyTempo.U_1.V_1.yyR8;
  942.  
  943.       {
  944.         register Tree_yRemote *W_14 = &t->U_1.V_17.Remote;
  945.  
  946.         W_13->TheClass = Tree_IdentifyClass(Tree_TreeRoot->U_1.V_26.Ag.Classes, W_14->Type);
  947.         if (W_13->TheClass != Tree_NoTree) {
  948.           Attr = Tree_IdentifyAttribute(W_13->TheClass, W_14->Attribute);
  949.           if (Attr != Tree_NoTree) {
  950.             {
  951.               register Tree_yAttribute *W_15 = &Attr->U_1.V_10.Attribute;
  952.  
  953.               W_13->k = EvalMod3_ToBit0(W_13->TheClass, (LONGINT)W_15->AttrIndex);
  954.               if (IN(Tree_Synthesized, W_15->Properties)) {
  955.                 IO_WriteS(Tree_f, (STRING)"REMOTE_SYN (yyIsComp", 20L);
  956.                 Tree_WN(W_13->k / TreeMod1_BSS);
  957.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  958.                 Tree_WN(W_13->k % TreeMod1_BSS);
  959.                 IO_WriteS(Tree_f, (STRING)", yyS", 5L);
  960.                 Tree_WN(W_13->k);
  961.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  962.                 EvalMod_GenEvaluator(W_14->Designators);
  963.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  964.                 Tree_WI(t->U_1.V_17.Remote.Type);
  965.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  966.                 Tree_WI(W_14->Attribute);
  967.                 IO_WriteS(Tree_f, (STRING)")", 1L);
  968.               } else if (IN(Tree_Inherited, W_15->Properties)) {
  969.                 IO_WriteS(Tree_f, (STRING)"REMOTE_INH (yyIsComp", 20L);
  970.                 Tree_WN(W_13->k / TreeMod1_BSS);
  971.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  972.                 Tree_WN(W_13->k % TreeMod1_BSS);
  973.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  974.                 Tree_WN(W_13->k);
  975.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  976.                 EvalMod_GenEvaluator(W_14->Designators);
  977.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  978.                 Tree_WI(t->U_1.V_17.Remote.Type);
  979.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  980.                 Tree_WI(W_14->Attribute);
  981.                 IO_WriteS(Tree_f, (STRING)")", 1L);
  982.               } else {
  983.                 EvalMod_GenEvaluator(W_14->Designators);
  984.                 IO_WriteS(Tree_f, (STRING)"^.", 2L);
  985.                 Tree_WI(t->U_1.V_17.Remote.Type);
  986.                 IO_WriteS(Tree_f, (STRING)".", 1L);
  987.                 Tree_WI(W_14->Attribute);
  988.               }
  989.             }
  990.           }
  991.         }
  992.         EvalMod_GenEvaluator(W_14->Next);
  993.         return;
  994.       }
  995.     }
  996.     break;
  997.   case Tree_Any:;
  998.     {
  999.       register Tree_yAny *W_16 = &t->U_1.V_18.Any;
  1000.  
  1001.       StringMem_WriteString(Tree_f, W_16->Code);
  1002.       EvalMod_GenEvaluator(W_16->Next);
  1003.       return;
  1004.     }
  1005.     break;
  1006.   case Tree_Anys:;
  1007.     {
  1008.       register Tree_yAnys *W_17 = &t->U_1.V_19.Anys;
  1009.  
  1010.       EvalMod_GenEvaluator(W_17->Layouts);
  1011.       EvalMod_GenEvaluator(W_17->Next);
  1012.       return;
  1013.     }
  1014.     break;
  1015.   case Tree_LayoutAny:;
  1016.     {
  1017.       register Tree_yLayoutAny *W_18 = &t->U_1.V_22.LayoutAny;
  1018.  
  1019.       StringMem_WriteString(Tree_f, W_18->Code);
  1020.       EvalMod_GenEvaluator(W_18->Next);
  1021.       return;
  1022.     }
  1023.     break;
  1024.   default :
  1025.     break;
  1026.   }
  1027. }
  1028.  
  1029. void EvalMod_BeginEvalMod
  1030. # ifdef __STDC__
  1031. ()
  1032. # else
  1033. ()
  1034. # endif
  1035. {
  1036. }
  1037.  
  1038. void EvalMod_CloseEvalMod
  1039. # ifdef __STDC__
  1040. ()
  1041. # else
  1042. ()
  1043. # endif
  1044. {
  1045. }
  1046.  
  1047. static void yyExit
  1048. # ifdef __STDC__
  1049. ()
  1050. # else
  1051. ()
  1052. # endif
  1053. {
  1054.   IO_CloseIO();
  1055.   Exit(1L);
  1056. }
  1057.  
  1058. void BEGIN_EvalMod()
  1059. {
  1060.   static BOOLEAN has_been_called = FALSE;
  1061.  
  1062.   if (!has_been_called) {
  1063.     has_been_called = TRUE;
  1064.  
  1065.     BEGIN_IO();
  1066.     BEGIN_Tree();
  1067.     BEGIN_System();
  1068.     BEGIN_IO();
  1069.     BEGIN_Tree();
  1070.     BEGIN_IO();
  1071.     BEGIN_StringMem();
  1072.     BEGIN_Texts();
  1073.     BEGIN_Sets();
  1074.     BEGIN_TreeMod1();
  1075.     BEGIN_TreeMod2();
  1076.     BEGIN_EvalMod3();
  1077.     BEGIN_Tree();
  1078.  
  1079.     EvalMod_yyf = IO_StdOutput;
  1080.     EvalMod_Exit = yyExit;
  1081.     EvalMod_BeginEvalMod();
  1082.   }
  1083. }
  1084.